home *** CD-ROM | disk | FTP | other *** search
/ System Booster / System Booster.iso / Texteditors / XDME / Src / io.c < prev    next >
C/C++ Source or Header  |  1996-09-26  |  8KB  |  447 lines
  1. /*
  2.  * CMD2.C
  3.  *
  4.  *    (C)Copyright 1987 by Matthew Dillon, All Rights Reserved
  5.  */
  6.  
  7. #include "defs.h"
  8.  
  9. Prototype int  do_edit         (void);
  10. Prototype int  do_bappendsave(void);
  11. Prototype int  do_bsave      (void);
  12. Prototype int  do_barpsave   (void);
  13. Prototype int  do_appendsave (void);
  14. Prototype int  do_save         (void);
  15. Prototype int  do_saveas     (void);
  16. Prototype int  do_aslsave    (void);
  17. Prototype int  do_reqsave    (void);
  18. Prototype int  saveit         (const char *);
  19. Prototype void do_cd         (void);
  20.  
  21.  
  22. typedef struct WBStartup    WBS;
  23. typedef struct DiskObject   DISKOBJ;
  24.  
  25.  
  26. #include "rexx.h"
  27.  
  28.  
  29. int do_edit (void)
  30. {
  31.     FILE *  fi;
  32.     BPTR    oldlock;
  33.     BPTR    new_lock;
  34.     LONG    lines;
  35.     UBYTE   buf[MAXLINELEN];
  36.     LINE    ptr;
  37.     BOOL    failed = 1;
  38.     BOOL    newfile = (av[0][0] == 'n');
  39.     ED      * ep       = Ep;
  40.  
  41.     text_sync ();
  42.  
  43.     if (newfile)
  44.     {    /* newfile or insfile */
  45.     if (ep->modified && getyn("XDME Warning", "Delete modified text ?", "Yes|No") == 0)
  46.         return (-1);
  47.  
  48.     ep = uninit_init (ep);
  49.  
  50.     strncpy ((char *)ep->name, (char *)av[1], 63);
  51.     ep->name[63] = 0;
  52.     ep->modified = 0;
  53.     }
  54.     else
  55.     {
  56.     ep->modified = 1;
  57.     }
  58.  
  59.     lines = ep->lines;
  60.     oldlock = CurrentDir (ep->dirlock);
  61.  
  62.     if (fi = fopen (av[1], "r"))
  63.     {
  64.     int  len;
  65.     char oktitle  = 1;
  66.  
  67.     /* Get lock for file */
  68.     if (newfile)
  69.     {
  70.         if (new_lock = Lock (av[1], SHARED_LOCK))
  71.         {
  72.         BOOL success;
  73.  
  74.         /* get full path */
  75.         success = NameFromLock (new_lock, tmp_buffer,
  76.                               sizeof (tmp_buffer));
  77.  
  78.         /* always unlock lock */
  79.         UnLock (new_lock);
  80.  
  81.         if (success)
  82.         {
  83.             strncpy (ep->name, FilePart (tmp_buffer),
  84.                               sizeof (ep->name)-1);
  85.             ep->name[sizeof(ep->name)-1] = 0;
  86.  
  87.             *(PathPart(tmp_buffer)) = 0;
  88.  
  89.             new_lock = Lock (tmp_buffer, SHARED_LOCK);
  90.  
  91.             UnLock (ep->dirlock);
  92.  
  93.             ep->dirlock = new_lock;
  94.         }
  95.         }
  96.     }
  97.  
  98.     title ("Loading %s ...", ep->name);
  99.  
  100.     while ((len = xefgets(fi, (char *)buf, MAXLINELEN-1)) >= 0)
  101.     {
  102.         failed = 0;
  103.         len ++;
  104.  
  105.         if (makeroom(256) && (ptr = allocline(len)))
  106.         {
  107.         SETLINE(ep,ep->lines,ptr);
  108.         ep->lines ++;
  109.  
  110.         movmem(buf, ptr, len);
  111.         } else
  112.         {
  113.         set_window_params ();
  114.         nomemory ();
  115.         oktitle = 0;
  116.         break;
  117.         }
  118.     }
  119.  
  120.     set_window_params ();
  121.  
  122.     if (oktitle)
  123.     {
  124.         title ("Loading OK");
  125.         globalflags.MForceTitle = TRUE;
  126.     }
  127.  
  128.     fclose (fi);
  129.     } else /* couldn't open file */
  130.     {
  131.     if (!newfile) /* insertfile ? */
  132.     {
  133.         warn ("File `%s' not found", av[1]);
  134.  
  135.         cmderr = CMD_FAILED;
  136.     } else
  137.     {
  138.         /* copy argument */
  139.         strcpy (tmp_buffer, av[1]);
  140.  
  141.         /* copy name of file */
  142.         strncpy (ep->name, FilePart (tmp_buffer), sizeof (ep->name)-1);
  143.         ep->name[sizeof(ep->name)-1] = 0;
  144.  
  145.         /* clip name off */
  146.         *(PathPart (tmp_buffer)) = 0;
  147.  
  148.         /* get new lock */
  149.         new_lock = Lock (tmp_buffer, SHARED_LOCK);
  150.  
  151.         /* unlock old lock */
  152.         UnLock (ep->dirlock);
  153.  
  154.         /* remember new lock */
  155.         ep->dirlock = new_lock;
  156.     }
  157.     }
  158.  
  159.     CurrentDir (oldlock);
  160.  
  161.     if (ep->lines != 1 && lines == 1 && *GETTEXT(ep,0) == 0)
  162.     {
  163.     ep->line     = 0;
  164.     freeline (GETLINE(ep,0));
  165.     bmovl (ep->list+1, ep->list, --ep->lines);
  166.     } else
  167.     {
  168.     if (!failed && lines <= ep->lines - 1)
  169.     {
  170.         /* INSFILE: move text to correct position */
  171.         ActualBlock.ep       = ep;
  172.         ActualBlock.start_line = lines;
  173.         ActualBlock.end_line   = ep->lines - 1;
  174.         ActualBlock.type       = BT_LINE;
  175.  
  176.         do_bmove ();
  177.     }
  178.     }
  179.  
  180.     set_window_params ();
  181.     window_title ();
  182.     text_load ();
  183.     text_redisplay ();
  184.  
  185.     return (!failed);
  186. } /* do_edit */
  187.  
  188.  
  189. static BOOL blockmode;
  190.  
  191. int do_appendsave (void)
  192. {
  193.     return (saveit ("a"));
  194. } /* do_appendsave */
  195.  
  196.  
  197. int do_bappendsave (void)
  198. {
  199.     int result = FALSE;
  200.  
  201.     if (block_ok ())
  202.     {
  203.     blockmode = 1;
  204.  
  205.     result = saveit ("a");
  206.  
  207.     blockmode = 0;
  208.     } else
  209.     error ("bappendsave:\nNo block specified");
  210.  
  211.     return (result);
  212. } /* do_bappendsave */
  213.  
  214.  
  215. int do_bsave (void)
  216. {
  217.     int result = FALSE;
  218.  
  219.     if (block_ok ())
  220.     {
  221.     blockmode = 1;
  222.  
  223.     result = saveit ("w");
  224.  
  225.     blockmode = 0;
  226.     } else
  227.     error ("bsave:\nNo block specified");
  228.  
  229.     return (result);
  230. } /* do_bsave() */
  231.  
  232.  
  233. int do_barpsave (void)
  234. {
  235.     int result = FALSE;
  236.  
  237.     if (block_ok ())
  238.     {
  239.     blockmode = 1;
  240.  
  241.     result = aslsave ();
  242.  
  243.     blockmode = 0;
  244.     } else
  245.     error ("barpsave:\nNo block specified");
  246.  
  247.     return (result);
  248. } /* do_barpsave */
  249.  
  250.  
  251. int do_save (void)
  252. {
  253.     av[1] = Ep->name;
  254.  
  255.     return (do_writeto ());
  256. } /* do_save() */
  257.  
  258.  
  259. int do_saveas (void)
  260. {
  261.     int ret = saveit ("w");
  262.  
  263.     do_chfilename ();
  264.  
  265.     return (ret);
  266. } /* do_saveas */
  267.  
  268.  
  269. Prototype int do_writeto (void);
  270.  
  271. int do_writeto (void)
  272. {
  273.     return (saveit ("w"));
  274. } /* do_writeto */
  275.  
  276.  
  277. int do_aslsave (void)
  278. {
  279.     return (aslsave ());
  280. } /* do_aslsave */
  281.  
  282.  
  283. int do_reqsave (void)
  284. {
  285.     return (reqsave ());
  286. } /* do_reqsave */
  287.  
  288.  
  289. int saveit (const char * om)   /* av: xxx filename */
  290. {
  291.     BPTR    oldlock;
  292.     FILE  * fi;
  293.     LONG    i;
  294.     WORD    j,
  295.         k;
  296.     UBYTE * ptr,
  297.       * bp,
  298.         buffer[MAXLINELEN];
  299.     Line    xs,
  300.         xe;
  301.     ED      * ep;
  302.  
  303.     if (!stricmp (av[1], "unnamed"))
  304.     {
  305.     return (do_aslsave ());
  306.     } else if (!stricmp (Ep->name, "unnamed"))  /* get new name */
  307.     {
  308.     strncpy (Ep->name, FilePart (av[1]), sizeof (Ep->name)-1);
  309.     Ep->name[sizeof(Ep->name)-1] = 0;
  310.     }
  311.  
  312.     if (blockmode) /* block is ok */
  313.     {
  314.     xs = ActualBlock.start_line;
  315.     xe = ActualBlock.end_line + 1;
  316.     ep = ActualBlock.ep;
  317.     } else
  318.     {
  319.     xs = 0;
  320.     xe = Ep->lines;
  321.     ep = Ep;
  322.     }
  323.  
  324.     text_sync ();
  325.     oldlock = CurrentDir (Ep->dirlock);
  326.  
  327.     if (Wbs && globalflags.Wdisable == 0)
  328.     {      /* Write out .info file */
  329.     DISKOBJ sdo, * d;
  330.  
  331.     memset (&sdo, 0, sizeof(sdo));
  332.  
  333.     if ((d = GetDiskObject ((char *)av[1])) == NULL)
  334.     {
  335.         /* Get path to XDME with name of the editor appended */
  336.         if (getpathto (Wbs->sm_ArgList[0].wa_Lock,
  337.                        Wbs->sm_ArgList[0].wa_Name, tmp_buffer))
  338.         {
  339.  
  340.         sdo.do_Magic   = WB_DISKMAGIC;
  341.         sdo.do_Version = WB_DISKVERSION;
  342.  
  343.         makemygadget (&sdo.do_Gadget);
  344.  
  345.         sdo.do_Type       = WBPROJECT;
  346.         sdo.do_DefaultTool = (char *)tmp_buffer;
  347.         sdo.do_ToolTypes   = NULL;
  348.         sdo.do_CurrentX    = NO_ICON_POSITION;
  349.         sdo.do_CurrentY    = NO_ICON_POSITION;
  350.         sdo.do_DrawerData  = NULL;
  351.         sdo.do_ToolWindow  = NULL;
  352.         sdo.do_StackSize   = 8192;
  353.  
  354.         PutDiskObject ((char *)av[1], &sdo);
  355.         }
  356.     } else
  357.     {
  358.         FreeDiskObject (d);
  359.     }
  360.     }
  361.  
  362.     if (fi = fopen (av[1], om))
  363.     {
  364.     title ("Saving ...");
  365.  
  366.     for (i = xs; i < xe; ++i)
  367.     {
  368.         ptr = GETTEXT(ep,i);
  369.  
  370.         if (globalflags.Savetabs)
  371.         {
  372.         for (bp = buffer, j = 0; *ptr; ++ptr, ++bp, j = (j+1)&7)
  373.         {
  374.             *bp = *ptr;
  375.             if (j == 7 && *bp == ' ' && *(bp-1) == ' ')
  376.             {
  377.             k = j;
  378.             while (k-- >= 0 && *bp == ' ')
  379.                 --bp;
  380.             *++bp = 9;
  381.             } else
  382.             {
  383.             if (globalflags.SimpleTabs)     /* PATCH_NULL [25 Jan 1993] : line added */
  384.                 break;            /* PATCH_NULL [25 Jan 1993] : line added */
  385.  
  386.             if (*bp < 32 || *bp == '\"' || *bp == '\'' || *bp == '`' || *bp == '(')
  387.                 break;
  388.             }
  389.         }
  390.         strcpy ((char *)bp, (char *)ptr);
  391.  
  392.         ptr = buffer;
  393.         }
  394.  
  395.         fputs (ptr, fi);
  396.         fputc ('\n', fi);
  397.     }
  398.     if (fclose (fi))
  399.     {
  400.         error ("save:\nWrite failed !");
  401.     } else
  402.     {
  403.         title ("Saving OK");
  404.         globalflags.MForceTitle = TRUE;
  405.  
  406.         /* Only remove modify if blockmode is OFF */
  407.         ep->modified = (ep->modified && blockmode);
  408.     }
  409.     } else
  410.     {
  411.     error ("save:\nUnable to open write file\n`%s'", av[1]);
  412.     }
  413.  
  414.     blockmode = 0;
  415.     CurrentDir (oldlock);
  416.  
  417.     window_title ();
  418.  
  419.     return (!globalflags.Abortcommand);
  420. } /* do_saveit() */
  421.  
  422.  
  423. /*
  424.  *  av[1] - Directory
  425.  */
  426.  
  427. void do_cd (void)
  428. {
  429.     BPTR oldlock;
  430.     BPTR lock;
  431.  
  432.     oldlock = CurrentDir (Ep->dirlock);
  433.  
  434.     if (lock = Lock (av[1], SHARED_LOCK))
  435.     {
  436.     UnLock (CurrentDir (oldlock));
  437.     Ep->dirlock = (long)lock;
  438.     } else
  439.     {
  440.     CurrentDir (oldlock);
  441.  
  442.     error ("cd:\nUnable to cd to\n`%s'", av[1]);
  443.     }
  444. } /* do_cd */
  445.  
  446.  
  447.